home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / mips / include / asm / fpu.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  3.2 KB  |  154 lines

  1. /*
  2.  * Copyright (C) 2002 MontaVista Software Inc.
  3.  * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License as published by the
  7.  * Free Software Foundation;  either version 2 of the  License, or (at your
  8.  * option) any later version.
  9.  */
  10. #ifndef _ASM_FPU_H
  11. #define _ASM_FPU_H
  12.  
  13. #include <linux/sched.h>
  14. #include <linux/thread_info.h>
  15. #include <linux/bitops.h>
  16.  
  17. #include <asm/mipsregs.h>
  18. #include <asm/cpu.h>
  19. #include <asm/cpu-features.h>
  20. #include <asm/hazards.h>
  21. #include <asm/processor.h>
  22. #include <asm/current.h>
  23.  
  24. #ifdef CONFIG_MIPS_MT_FPAFF
  25. #include <asm/mips_mt.h>
  26. #endif
  27.  
  28. struct sigcontext;
  29. struct sigcontext32;
  30.  
  31. extern asmlinkage int (*save_fp_context)(struct sigcontext __user *sc);
  32. extern asmlinkage int (*restore_fp_context)(struct sigcontext __user *sc);
  33.  
  34. extern asmlinkage int (*save_fp_context32)(struct sigcontext32 __user *sc);
  35. extern asmlinkage int (*restore_fp_context32)(struct sigcontext32 __user *sc);
  36.  
  37. extern void fpu_emulator_init_fpu(void);
  38. extern int fpu_emulator_save_context(struct sigcontext __user *sc);
  39. extern int fpu_emulator_restore_context(struct sigcontext __user *sc);
  40. extern void _init_fpu(void);
  41. extern void _save_fp(struct task_struct *);
  42. extern void _restore_fp(struct task_struct *);
  43.  
  44. #define __enable_fpu()                            \
  45. do {                                    \
  46.         set_c0_status(ST0_CU1);                        \
  47.         enable_fpu_hazard();                        \
  48. } while (0)
  49.  
  50. #define __disable_fpu()                            \
  51. do {                                    \
  52.     clear_c0_status(ST0_CU1);                    \
  53.         disable_fpu_hazard();                        \
  54. } while (0)
  55.  
  56. #define enable_fpu()                            \
  57. do {                                    \
  58.     if (cpu_has_fpu)                        \
  59.         __enable_fpu();                        \
  60. } while (0)
  61.  
  62. #define disable_fpu()                            \
  63. do {                                    \
  64.     if (cpu_has_fpu)                        \
  65.         __disable_fpu();                    \
  66. } while (0)
  67.  
  68.  
  69. #define clear_fpu_owner()    clear_thread_flag(TIF_USEDFPU)
  70.  
  71. static inline int __is_fpu_owner(void)
  72. {
  73.     return test_thread_flag(TIF_USEDFPU);
  74. }
  75.  
  76. static inline int is_fpu_owner(void)
  77. {
  78.     return cpu_has_fpu && __is_fpu_owner();
  79. }
  80.  
  81. static inline void __own_fpu(void)
  82. {
  83.     __enable_fpu();
  84.     KSTK_STATUS(current) |= ST0_CU1;
  85.     set_thread_flag(TIF_USEDFPU);
  86. }
  87.  
  88. static inline void own_fpu_inatomic(int restore)
  89. {
  90.     if (cpu_has_fpu && !__is_fpu_owner()) {
  91.         __own_fpu();
  92.         if (restore)
  93.             _restore_fp(current);
  94.     }
  95. }
  96.  
  97. static inline void own_fpu(int restore)
  98. {
  99.     preempt_disable();
  100.     own_fpu_inatomic(restore);
  101.     preempt_enable();
  102. }
  103.  
  104. static inline void lose_fpu(int save)
  105. {
  106.     preempt_disable();
  107.     if (is_fpu_owner()) {
  108.         if (save)
  109.             _save_fp(current);
  110.         KSTK_STATUS(current) &= ~ST0_CU1;
  111.         clear_thread_flag(TIF_USEDFPU);
  112.         __disable_fpu();
  113.     }
  114.     preempt_enable();
  115. }
  116.  
  117. static inline void init_fpu(void)
  118. {
  119.     preempt_disable();
  120.     if (cpu_has_fpu) {
  121.         __own_fpu();
  122.         _init_fpu();
  123.     } else {
  124.         fpu_emulator_init_fpu();
  125.     }
  126.     preempt_enable();
  127. }
  128.  
  129. static inline void save_fp(struct task_struct *tsk)
  130. {
  131.     if (cpu_has_fpu)
  132.         _save_fp(tsk);
  133. }
  134.  
  135. static inline void restore_fp(struct task_struct *tsk)
  136. {
  137.     if (cpu_has_fpu)
  138.         _restore_fp(tsk);
  139. }
  140.  
  141. static inline fpureg_t *get_fpu_regs(struct task_struct *tsk)
  142. {
  143.     if (tsk == current) {
  144.         preempt_disable();
  145.         if (is_fpu_owner())
  146.             _save_fp(current);
  147.         preempt_enable();
  148.     }
  149.  
  150.     return tsk->thread.fpu.fpr;
  151. }
  152.  
  153. #endif /* _ASM_FPU_H */
  154.